home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / 118_01.zip / CONVERT.BDS < prev    next >
Text File  |  1993-06-03  |  8KB  |  438 lines
  1. /* Conversion routines for Software Tools
  2.  * source:  convert.bds
  3.  * version: July 28, 1981
  4.  */
  5.  
  6. #include tools.h
  7.  
  8. /*    ctoi - convert string at in[i] to int, increment *i.
  9.  *             increment i.
  10.  *             calling sequence:  ctoi(buffer, &i);
  11.  */
  12.  
  13. ctoi(in, i)
  14. char *in;
  15. int *i;
  16. {
  17.     while (in[*i] == ' ' || in[*i] == TAB) {
  18.         (*i)++;
  19.     }
  20.     /* note:  i still points at beginning of number */
  21.     return(atoi(in + *i));
  22. }
  23.  
  24. /*  ctomn - translate ASCII control char to mnemonic string */
  25.  
  26. /* comment out -----
  27. ctomn (c, rep)
  28. char c, rep[4]
  29. {
  30.  
  31.     int i;
  32.     char *s;
  33.  
  34.     i = c & 127;
  35.     if (0 <= i && i <= 32) {
  36.         /* non-printing char or space */
  37.         switch(i) {
  38.     case  0:    s = "NUL";    break;
  39.     case  1:    s = "SOH";    break;
  40.     case  2:    s = "STX";    break;
  41.     case  3:    s = "ETX";    break;
  42.     case  4:    s = "EOT";    break;
  43.     case  5:    s = "ENG";    break;
  44.     case  6:   s = "ACK";    break;
  45.     case  7:   s = "BEL";    break;
  46.     case  8:   s = "BS";    break;
  47.     case  9:    s = "HT";    break;
  48.     case 10:    s = "LF";    break;
  49.     case 11:    s = "VT";    break;
  50.     case 12:    s = "FF";    break;
  51.     case 13:    s = "CR";    break;
  52.     case 14:    s = "SO";    break;
  53.     case 15:    s = "SI";    break;
  54.     case 16:    s = "DLE";    break;
  55.     case 17:    s = "DC1";    break;
  56.     case 18:    s = "DC2";    break;
  57.     case 19:    s = "DC3";    break;
  58.     case 20:    s = "DC4";    break;
  59.     case 21:    s = "NAK";    break;
  60.     case 22:    s = "SYN";    break;
  61.     case 23:    s = "ETB";    break;
  62.     case 24:    s = "CAN";    break;
  63.     case 25:    s = "EM";    break;
  64.     case 26:    s = "SUB";    break;
  65.     case 27:    s = "ESC";    break;
  66.     case 28:    s = "FS";    break;
  67.     case 29:    s = "GS";    break;
  68.     case 30:    s = "RS";    break;
  69.     case 31:    s = "VS";    break;
  70.         }
  71.         scopy (s, 1, rep, 1);
  72.     }
  73.     else if (i == 127) {
  74.         /* rubout (DEL) */
  75.         scopy ("DEL", 1, rep, 1);
  76.     }
  77.     else {
  78.         /* printing character */
  79.         rep[1] = c;
  80.         rep[2] = EOS;
  81.     }
  82.     return (length (rep));
  83. }
  84. ----- end comment out */
  85.  
  86. /*  gctoi - convert any radix string to single precision int
  87.  *          increment i.
  88.  *          calling sequence:  gctoi(str, &i, radix);
  89.  */
  90.  
  91. /* comment out -----
  92. gctoi (str, ii, radix)
  93. char str[];
  94. int *ii, radix;
  95. {
  96.  
  97.     int base, i, v, d, j;
  98.  
  99.     BOOL neg
  100.  
  101.     i = *ii;
  102.  
  103.     v = 0;
  104.     base = radix;
  105.  
  106.     while (str[i] == ' ' || str[i] == TAB) {
  107.         i++;
  108.     }
  109.  
  110.     neg = (str[i] == '-');
  111.     if (str[i] == '+' || str[i] == '-') {
  112.         i++;
  113.     }
  114.  
  115.     if ( ( str[i+2] == 'r' &&
  116.            str[i]   == '1' &&
  117.            IS_DIGIT(str[i+1]))    ||
  118.          ( str[i+1] == 'r' &&
  119.            IS_DIGIT(str[i])
  120.        ) {
  121.  
  122.         base = str[i] - '0';
  123.         j = i;
  124.         if (str (i + 1) != 'r') {
  125.             j++;
  126.             base = base * 10 + (str[j] - '0')
  127.         }
  128.         if (base < 2 | base > 16) {
  129.             base = radix;
  130.         }
  131.         else {
  132.             i = j + 2;
  133.         }
  134.     }
  135.     for (; str[i] != EOS; i++) {
  136.         if (IS_DIGIT(str[i])) {
  137.             d = str[i] - '0'
  138.         }
  139.         else {
  140.             d = index (digits, clower (str[i])) - 1;
  141.         if (d < 0 || d >= base) {
  142.             break;
  143.         }
  144.         v = v * base + d
  145.     }
  146.  
  147.     *ii = i;
  148.     if (neg) {
  149.         return (-v);
  150.     }
  151.     else {
  152.         return (+v);
  153.     }
  154. }
  155. ----- end comment out */
  156.  
  157. /*  gitoc - convert single precision int to any radix string
  158.  *          
  159.  */
  160.  
  161. /* comment out -----
  162. gitoc (int, str, size, base)
  163. int int, size, base;
  164. char str [size];
  165. {
  166.  
  167.     int carry, d, i, radix, n;
  168.     int value;
  169.     logical unsign;
  170.  
  171.  
  172.     /* digit string is generated backwards, then reversed */
  173.     str[1] = EOS;
  174.     if (size <= 1) {
  175.         return[0];
  176.     }
  177.     radix = abs(base);
  178.     if (radix < 2 || radix > 16) {
  179.         radix = 10;
  180.     }
  181.  
  182.     /* negative radices mean unsign conversion */
  183.     unsign = (base < 0);
  184.  
  185.     if (unsign) {
  186.         /* make positive, but keep high-order bits intact */
  187.         n = (int / 2) & (MAX_INTERGER);
  188.         carry = int & 1;    /*  get initial carry */
  189.     }
  190.     else {
  191.         n = int;
  192.     }
  193.     i = 1;
  194.     repeat {
  195.         d = abs (n % radix);  /*  generate next digit */
  196.         if (unsign) {      /*  this is only half of actual digit value */
  197.             d = 2 * d + carry    /*  get actual digit value */
  198.             if (d >= radix) {    /*  check for generated carry */
  199.                 d -= radix
  200.                 carry = 1
  201.             }
  202.             else {
  203.                 carry = 0
  204.             }
  205.         }
  206.         i++;
  207.         if (str[i] < 10) {
  208.             str[i] += '0';
  209.         }
  210.         else {
  211.             str[i] += 'A' - 10;
  212.         }
  213.         n /= radix
  214.     } until (n == 0 || i >= size);
  215.  
  216.     if (unsign) {
  217.         if (carry != 0 & i < size) {    /*  check for final carry */
  218.             i++;
  219.             str[i] = '1';
  220.         }
  221.     }
  222.     else if (int < 0 && i < size) {  /*  add sign if needed */
  223.         i++;
  224.         str[i] = '-';
  225.     }
  226.  
  227.     value = i - 1;     /*  will return length of string */
  228.  
  229.     for (d = 1; d < i; d++) {     /*  reverse digits */
  230.         carry = str[d];
  231.         str[d] = str[i];
  232.         str[i] = carry;
  233.         i--;
  234.     }
  235.     return (value);
  236. }
  237. ----- end comment out */
  238.  
  239. /*  mntoc - translate ASCII mnemonic into a char */
  240.  
  241. /* comment out -----
  242.     char mntoc (buf, p, default)
  243.     char buf[], default
  244.     int p
  245.  
  246.     int i, tp
  247.     int equal
  248.  
  249.     char c, tmp (MAXLINE)
  250.  
  251.     char text (170)
  252.     data text / _
  253.         ACK, LETA, LETC, LETK, EOS,
  254.         BEL, LETB, LETE, LETL, EOS,
  255.         BS,  LETB, LETS, EOS,  EOS,
  256.         CAN, LETC, LETA, LETN, EOS,
  257.         CR,  LETC, LETR, EOS,  EOS,
  258.         DC1, LETD, LETC, DIG1, EOS,
  259.         DC2, LETD, LETC, DIG2, EOS,
  260.         DC3, LETD, LETC, DIG3, EOS,
  261.         DC4, LETD, LETC, DIG4, EOS,
  262.         DEL, LETD, LETE, LETL, EOS,
  263.         DLE, LETD, LETL, LETE, EOS,
  264.         EM,  LETE, LETM, EOS,  EOS,
  265.         ENQ, LETE, LETN, LETQ, EOS,
  266.         EOT, LETE, LETO, LETT, EOS,
  267.         ESC, LETE, LETS, LETC, EOS,
  268.         ETB, LETE, LETT, LETB, EOS,
  269.         ETX, LETE, LETT, LETX, EOS,
  270.         FF,  LETF, LETF, EOS,  EOS,
  271.         FS,  LETF, LETS, EOS,  EOS,
  272.         GS,  LETG, LETS, EOS,  EOS,
  273.         HT,  LETH, LETT, EOS,  EOS,
  274.         LF,  LETL, LETF, EOS,  EOS,
  275.         NAK, LETN, LETA, LETK, EOS,
  276.         NUL, LETN, LETU, LETL, EOS,
  277.         RS,  LETR, LETS, EOS,  EOS,
  278.         SI,  LETS, LETI, EOS,  EOS,
  279.         SO,  LETS, LETO, EOS,  EOS,
  280.         SOH, LETS, LETO, LETH, EOS,
  281.         SP,  LETS, LETP, EOS,  EOS,
  282.         STX, LETS, LETT, LETX, EOS,
  283.         SUB, LETS, LETU, LETB, EOS,
  284.         SYN, LETS, LETY, LETN, EOS,
  285.         US,  LETU, LETS, EOS,  EOS,
  286.         VT,  LETV, LETT, EOS,  EOS/
  287.  
  288.     tp = 1
  289.     repeat {
  290.         tmp (tp) = buf[p]
  291.         tp = tp + 1
  292.         p++
  293.         } until (! (IS_LETTER(buf[p]) | IS_DIGIT(buf[p]))
  294.                         | tp >= MAXLINE)
  295.     tmp (tp) = EOS
  296.  
  297.     if (tp == 2)
  298.         c = tmp[1]
  299.     else {
  300.         lower (tmp)
  301.         for (i = 1; i < 170; i = i + 5)  /*  should use binary search here */
  302.             if (equal (tmp, text (i + 1)) == YES)
  303.                 break
  304.         if (i < 170)
  305.             c = text[i]
  306.         else
  307.             c = default
  308.         }
  309.  
  310.     return[c]
  311. }
  312. ----- end comment out */
  313.  
  314. /*  upper - fold all alphas to upper case */
  315.  
  316. upper (token)
  317. char *token;
  318. {
  319.  
  320.     int i;
  321.  
  322.     for (i = 0; token[i] != EOS; i++) {
  323.         token[i] = toupper(token[i]);
  324.     }
  325. }
  326.  
  327.  
  328. /*  lower - fold all letters to lower case */
  329.  
  330. lower (token)
  331. char *token;
  332. {
  333.  
  334.     int i;
  335.  
  336.     for (i  = 0; token [i] != EOS; i++) {
  337.         token [i] = tolower(token [i]);
  338.     }
  339. }
  340.  
  341. /*  ctoc - copy the from string. Truncate after len chars */
  342.  
  343. ctoc (from, to, len)
  344. int len;
  345. char *from, *to;
  346. {
  347.  
  348.     int i;
  349.  
  350.     for (i = 0; i < len && from [i] != EOS; i++) {
  351.         to [i] = from [i];
  352.     }
  353.     to [i] = EOS;
  354.  
  355.     return (i);
  356. }
  357.  
  358. /*  fold - fold all letters in a string to lower case */
  359.  
  360. fold (token)
  361. char *token;
  362. {
  363.     lower (token);
  364. }
  365.  
  366. /*  itoc - convert int  int  to char string in  str */
  367.  
  368. itoc (n, str, size)
  369. int n, size;
  370. char *str;
  371. {
  372.  
  373.     int l;
  374.  
  375.     sprintf(str, "%d", n);
  376.     if ((l = length(str)) >= size) {
  377.         sys_error("itoc\n");
  378.     }
  379.     return(l);
  380. }
  381.  
  382. /* comment out ----------
  383.     int d, i, intval, j, k;
  384.  
  385.     intval = abs (n);
  386.     str [0] = EOS
  387.     for (i = 1;intval == 0 || i > size - 2;i++) {
  388.         i++;
  389.         str [i] = '0' + (intval % 10);
  390.         intval = intval / 10;
  391.     }
  392.  
  393.     if (n < 0 && i < size) {         /*  then sign */
  394.         i = i + 1
  395.         str (i) = MINUS
  396.         }
  397.     itoc = i - 1
  398.  
  399.     for (j = 1; j < i; j = j + 1) {   /*  then reverse */
  400.         k = str (i)
  401.         str (i) = str (j)
  402.         str (j) = k
  403.         i = i - 1
  404.         }
  405. }
  406. ----- end comment out */
  407.  
  408. Truncate after len chars */
  409.  
  410. ctoc (from, to, len)
  411. int len;
  412. char *from, *to;
  413. {
  414.  
  415.     int i;
  416.  
  417.     for (i = 0
  418.     str [0] = EOS
  419.     for (i = 1;intval == 0 || i > size - 2;i++) {
  420.         i++;
  421.         str [i] = '0' + (intval % 10);
  422.         intval = intval / 10;
  423.     }
  424.  
  425.     if (n < 0 && i < size) {         /*  then sign */
  426.         i = i + 1
  427.         str (i) = MINUS
  428.         }
  429.     itoc = i - 1
  430.  
  431.     for (j = 1; j < i; j = j + 1) {   /*  then reverse */
  432.         k = str (i)
  433.         str (i) = str (j)
  434.         str (j) = k
  435.         i = i - 1
  436.         }
  437. }
  438. ----- end